…ge cases

Existing peer-access tests covered the integration path well (real
copies across peers, the full transition matrix, shared-pool consistency)
but only touched ``in``, ``==``, and the property setter on the new set
proxy. After the v1.0.0 break that surfaced ~25 ``MutableSet`` methods,
nothing was pinning the type-coercion contract, the owner-filtering
behavior, the ``KeyError``/value-error paths, or the "one
``cuMemPoolSetAccess`` per bulk op" performance invariant.

Add the following coverage in ``test_memory_peer_access.py``:

- A ``MutableSet`` conformance test using a relaxed
  ``assert_mutable_set_interface`` mode that admits subjects holding at
  most one insertable element. CI maxes at two GPUs (one peer), so the
  multi-element protocol pass cannot run there. The new
  ``support_multi_insert=False`` path takes one insertable item plus two
  non-member sentinels and exercises every ``MutableSet`` method
  (``add``/``discard``/``remove``/``pop``/``clear``/``update``,
  comparisons, isdisjoint, subset/superset, binary and in-place
  operators, ``__iter__``/``__len__``/``__repr__``).
- ``Device``/``int`` interchangeability on ``add``/``discard``/``__contains__``.
- The owner-device filtering contract on every write (silent no-op).
- Error paths: ``add(out_of_range)`` and ``add(non_coercible)`` raise
  while the lenient ``discard``/``__contains__`` paths swallow the same
  inputs; ``remove(non_member)`` raises ``KeyError``.
- "Live driver view" semantics: a proxy obtained before another wrapper
  modifies the pool reflects the change with no refresh step.
- ``__iter__`` ordering is ascending by ``device_id`` and elements are
  ``Device`` instances; ``__repr__`` includes the class name and tracks
  live contents; the getter returns the documented proxy type.
- A batching spy that monkeypatches the module-level
  ``_apply_peer_access_diff`` and asserts that every bulk op
  (``|=``/``&=``/``-=``/``^=``/``update``/``difference_update``/
  ``clear``) and the property setter issues at most one driver call,
  zero when the diff is empty.

To make the spy possible, ``_apply_peer_access_diff`` is now a
Python-visible ``def`` wrapper around a renamed
``_apply_peer_access_diff_cython`` ``cdef inline``. The proxy and the
property setter still call ``_apply_peer_access_diff`` by bare name,
which Cython resolves through the module's globals at runtime, so a
``monkeypatch.setattr(_peer_access_utils, "_apply_peer_access_diff", ...)``
intercepts them. The extra Python-level dispatch is negligible next to
``cuMemPoolSetAccess`` itself.

Co-authored-by: Cursor <cursoragent@cursor.com>

Augmented assignment on the ``peer_accessible_by`` property
(``dmr.peer_accessible_by |= {...}``) is two trips through the
proxy/setter pair, not one: Python fetches the proxy, the proxy mutates
itself in place via ``__ior__``, and Python then assigns the
(already-mutated) proxy back through the setter. That trailing setter
call computes the diff against current driver state, finds it empty,
and short-circuits inside the ``cdef inline`` before issuing any
``cuMemPoolSetAccess`` work — so the *driver-level* contract ("one
batched call per bulk op") still holds, but the wrapper is invoked
twice, which the spy was counting.

Also, the fixture's ``dmr.peer_accessible_by = []`` reset on an already
empty pool is itself an empty-delta wrapper call.

Filter the recorded calls down to those with non-empty deltas (the ones
that translate to real driver work) and switch the bulk-ops test to use
a locally bound proxy so augmented assignment goes through ``__ior__``
once with no extra setter invocation. The setter test stays on
``dmr.peer_accessible_by = ...`` because that is the public API
contract under test there.

Co-authored-by: Cursor <cursoragent@cursor.com>

…hing

Move the actual ``cuMemPoolSetAccess`` invocation (descriptor-array
build + driver call) into a thin Python-visible ``def _set_pool_access``
in ``_peer_access_utils.pyx``. ``_apply_peer_access_diff`` now does only
the empty-diff short-circuit and delegates the work to
``_set_pool_access``, which Cython resolves through the module globals
at runtime so tests can intercept it via ``monkeypatch.setattr``.

Replace the previous internal-wrapper spy with a driver-call spy that
counts every real ``cuMemPoolSetAccess`` invocation. Earlier no-op
layers (e.g. the augmented-assignment-on-property pattern that writes
an already-mutated proxy back through the setter) short-circuit before
reaching ``_set_pool_access``, so the recorded count is exactly the
number of driver calls. The empty-delta filter and the local-binding
workaround in the bulk-ops test are gone; we now also assert that
``dmr.peer_accessible_by |= {...}`` directly on the property is still
exactly one driver call.

Co-authored-by: Cursor <cursoragent@cursor.com>

Replace the ``support_multi_insert`` flag and ``non_members`` keyword
with two purpose-built helpers:

- ``assert_mutable_set_interface(subject, items)`` keeps the original
  signature and contract: at least five distinct insertable items,
  exercised against a reference set in the standard way. The graph
  ``AdjacencySetProxy`` test continues to use this unchanged.
- ``assert_single_member_mutable_set_interface(subject, member,
  non_member)`` is a focused pass for proxies whose backing store admits
  at most one insertable element at a time (here, the peer-access view
  on a 2-GPU box). It threads a single member and one non-member
  sentinel through every ``MutableSet`` method.

The two helpers share small private utilities (empty-state checks,
``__repr__`` shape) but keep their public surfaces small and linear.
A capacity-one proxy is a meaningfully different contract from a
general mutable set; naming that explicitly in the API reads better
than a flag and avoids forcing call sites to plumb sentinels through.

Co-authored-by: Cursor <cursoragent@cursor.com>

…-by-set-proxy

Co-authored-by: Cursor <cursoragent@cursor.com>

# Conflicts:
#	cuda_core/docs/source/api_private.rst

…-by-set-proxy

Co-authored-by: Cursor <cursoragent@cursor.com>

# Conflicts:
#	cuda_core/docs/source/api_private.rst
#	cuda_core/docs/source/release/1.0.0-notes.rst

…-by-set-proxy

Co-authored-by: Cursor <cursoragent@cursor.com>

# Conflicts:
#	cuda_core/cuda/core/_memory/_device_memory_resource.pyx